home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / ext2fs / ext2fs.h < prev   
C/C++ Source or Header  |  2006-04-25  |  35KB  |  1,141 lines
  1. /*
  2.  * ext2fs.h --- ext2fs
  3.  * 
  4.  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  5.  *
  6.  * %Begin-Header%
  7.  * This file may be redistributed under the terms of the GNU Public
  8.  * License.
  9.  * %End-Header%
  10.  */
  11.  
  12. #ifndef _EXT2FS_EXT2FS_H
  13. #define _EXT2FS_EXT2FS_H
  14.  
  15. #ifdef __GNUC__
  16. #define EXT2FS_ATTR(x) __attribute__(x)
  17. #else
  18. #define EXT2FS_ATTR(x)
  19. #endif
  20.  
  21. #ifdef __cplusplus
  22. extern "C" {
  23. #endif
  24.  
  25. /*
  26.  * Non-GNU C compilers won't necessarily understand inline
  27.  */
  28. #if (!defined(__GNUC__) && !defined(__WATCOMC__))
  29. #define NO_INLINE_FUNCS
  30. #endif
  31.  
  32. /*
  33.  * Build in support for byte-swapping filesystems if we the feature
  34.  * has been configured or if we're being built on a CPU architecture
  35.  * with a non-native byte order.
  36.  */
  37. #if defined(ENABLE_SWAPFS) || defined(WORDS_BIGENDIAN)
  38. #define EXT2FS_ENABLE_SWAPFS
  39. #endif
  40.  
  41. /*
  42.  * Where the master copy of the superblock is located, and how big
  43.  * superblocks are supposed to be.  We define SUPERBLOCK_SIZE because
  44.  * the size of the superblock structure is not necessarily trustworthy
  45.  * (some versions have the padding set up so that the superblock is
  46.  * 1032 bytes long).
  47.  */
  48. #define SUPERBLOCK_OFFSET    1024
  49. #define SUPERBLOCK_SIZE     1024
  50.  
  51. /*
  52.  * The last ext2fs revision level that this version of the library is
  53.  * able to support.
  54.  */
  55. #define EXT2_LIB_CURRENT_REV    EXT2_DYNAMIC_REV
  56.  
  57. #ifdef HAVE_SYS_TYPES_H
  58. #include <sys/types.h>
  59. #endif
  60.  
  61. #include <stdio.h>
  62. #include <stdlib.h>
  63.  
  64. #if EXT2_FLAT_INCLUDES
  65. #include "e2_types.h"
  66. #include "ext2_fs.h"
  67. #else
  68. #include <ext2fs/ext2_types.h>
  69. #include <ext2fs/ext2_fs.h>
  70. #endif /* EXT2_FLAT_INCLUDES */
  71.  
  72. typedef __u32        ext2_ino_t;
  73. typedef __u32        blk_t;
  74. typedef __u32        dgrp_t;
  75. typedef __u32        ext2_off_t;
  76. typedef __s64        e2_blkcnt_t;
  77. typedef __u32        ext2_dirhash_t;
  78.  
  79. #if EXT2_FLAT_INCLUDES
  80. #include "com_err.h"
  81. #include "ext2_io.h"
  82. #include "ext2_err.h"
  83. #else
  84. #include <et/com_err.h>
  85. #include <ext2fs/ext2_io.h>
  86. #include <ext2fs/ext2_err.h>
  87. #endif
  88.  
  89. /*
  90.  * Portability help for Microsoft Visual C++
  91.  */
  92. #ifdef _MSC_VER
  93. #define EXT2_QSORT_TYPE int __cdecl
  94. #else
  95. #define EXT2_QSORT_TYPE int
  96. #endif
  97.  
  98. typedef struct struct_ext2_filsys *ext2_filsys;
  99.  
  100. struct ext2fs_struct_generic_bitmap {
  101.     errcode_t    magic;
  102.     ext2_filsys     fs;
  103.     __u32        start, end;
  104.     __u32        real_end;
  105.     char    *    description;
  106.     char    *    bitmap;
  107.     errcode_t    base_error_code;
  108.     __u32        reserved[7];
  109. };
  110.  
  111. #define EXT2FS_MARK_ERROR     0
  112. #define EXT2FS_UNMARK_ERROR     1
  113. #define EXT2FS_TEST_ERROR    2
  114.  
  115. typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap;
  116. typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap;
  117. typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap;
  118.  
  119. #ifdef EXT2_DYNAMIC_REV
  120. #define EXT2_FIRST_INODE(s)    EXT2_FIRST_INO(s)
  121. #else
  122. #define EXT2_FIRST_INODE(s)    EXT2_FIRST_INO
  123. #define EXT2_INODE_SIZE(s)    sizeof(struct ext2_inode)
  124. #endif
  125.  
  126. /*
  127.  * badblocks list definitions
  128.  */
  129.  
  130. typedef struct ext2_struct_u32_list *ext2_badblocks_list;
  131. typedef struct ext2_struct_u32_iterate *ext2_badblocks_iterate;
  132.  
  133. typedef struct ext2_struct_u32_list *ext2_u32_list;
  134. typedef struct ext2_struct_u32_iterate *ext2_u32_iterate;
  135.  
  136. /* old */
  137. typedef struct ext2_struct_u32_list *badblocks_list;
  138. typedef struct ext2_struct_u32_iterate *badblocks_iterate;
  139.  
  140. #define BADBLOCKS_FLAG_DIRTY    1
  141.  
  142. /*
  143.  * ext2_dblist structure and abstractions (see dblist.c)
  144.  */
  145. struct ext2_db_entry {
  146.     ext2_ino_t    ino;
  147.     blk_t    blk;
  148.     int    blockcnt;
  149. };
  150.  
  151. typedef struct ext2_struct_dblist *ext2_dblist;
  152.  
  153. #define DBLIST_ABORT    1
  154.  
  155. /*
  156.  * ext2_fileio definitions
  157.  */
  158.  
  159. #define EXT2_FILE_WRITE        0x0001
  160. #define EXT2_FILE_CREATE    0x0002
  161.  
  162. #define EXT2_FILE_MASK        0x00FF
  163.  
  164. #define EXT2_FILE_BUF_DIRTY    0x4000
  165. #define EXT2_FILE_BUF_VALID    0x2000
  166.  
  167. typedef struct ext2_file *ext2_file_t;
  168.  
  169. #define EXT2_SEEK_SET    0
  170. #define EXT2_SEEK_CUR    1
  171. #define EXT2_SEEK_END    2
  172.  
  173. /*
  174.  * Flags for the ext2_filsys structure and for ext2fs_open()
  175.  */
  176. #define EXT2_FLAG_RW            0x01
  177. #define EXT2_FLAG_CHANGED        0x02
  178. #define EXT2_FLAG_DIRTY            0x04
  179. #define EXT2_FLAG_VALID            0x08
  180. #define EXT2_FLAG_IB_DIRTY        0x10
  181. #define EXT2_FLAG_BB_DIRTY        0x20
  182. #define EXT2_FLAG_SWAP_BYTES        0x40
  183. #define EXT2_FLAG_SWAP_BYTES_READ    0x80
  184. #define EXT2_FLAG_SWAP_BYTES_WRITE    0x100
  185. #define EXT2_FLAG_MASTER_SB_ONLY    0x200
  186. #define EXT2_FLAG_FORCE            0x400
  187. #define EXT2_FLAG_SUPER_ONLY        0x800
  188. #define EXT2_FLAG_JOURNAL_DEV_OK    0x1000
  189. #define EXT2_FLAG_IMAGE_FILE        0x2000
  190.  
  191. /*
  192.  * Special flag in the ext2 inode i_flag field that means that this is
  193.  * a new inode.  (So that ext2_write_inode() can clear extra fields.)
  194.  */
  195. #define EXT2_NEW_INODE_FL    0x80000000
  196.  
  197. /*
  198.  * Flags for mkjournal
  199.  *
  200.  * EXT2_MKJOURNAL_V1_SUPER    Make a (deprecated) V1 journal superblock
  201.  */
  202. #define EXT2_MKJOURNAL_V1_SUPER    0x0000001
  203.  
  204. struct struct_ext2_filsys {
  205.     errcode_t            magic;
  206.     io_channel            io;
  207.     int                flags;
  208.     char *                device_name;
  209.     struct ext2_super_block    *     super;
  210.     unsigned int            blocksize;
  211.     int                fragsize;
  212.     dgrp_t                group_desc_count;
  213.     unsigned long            desc_blocks;
  214.     struct ext2_group_desc *    group_desc;
  215.     int                inode_blocks_per_group;
  216.     ext2fs_inode_bitmap        inode_map;
  217.     ext2fs_block_bitmap        block_map;
  218.     errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
  219.     errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino);
  220.     errcode_t (*write_bitmaps)(ext2_filsys fs);
  221.     errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino,
  222.                 struct ext2_inode *inode);
  223.     errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino,
  224.                 struct ext2_inode *inode);
  225.     ext2_badblocks_list        badblocks;
  226.     ext2_dblist            dblist;
  227.     __u32                stride;    /* for mke2fs */
  228.     struct ext2_super_block *    orig_super;
  229.     struct ext2_image_hdr *        image_header;
  230.     __u32                umask;
  231.     /*
  232.      * Reserved for future expansion
  233.      */
  234.     __u32                reserved[8];
  235.  
  236.     /*
  237.      * Reserved for the use of the calling application.
  238.      */
  239.     void *                priv_data;
  240.  
  241.     /*
  242.      * Inode cache
  243.      */
  244.     struct ext2_inode_cache        *icache;
  245.     io_channel            image_io;
  246. };
  247.  
  248. #if EXT2_FLAT_INCLUDES
  249. #include "e2_bitops.h"
  250. #else
  251. #include <ext2fs/bitops.h>
  252. #endif
  253.  
  254. /*
  255.  * Return flags for the block iterator functions
  256.  */
  257. #define BLOCK_CHANGED    1
  258. #define BLOCK_ABORT    2
  259. #define BLOCK_ERROR    4
  260.  
  261. /*
  262.  * Block interate flags
  263.  *
  264.  * BLOCK_FLAG_APPEND, or BLOCK_FLAG_HOLE, indicates that the interator
  265.  * function should be called on blocks where the block number is zero.
  266.  * This is used by ext2fs_expand_dir() to be able to add a new block
  267.  * to an inode.  It can also be used for programs that want to be able
  268.  * to deal with files that contain "holes".
  269.  * 
  270.  * BLOCK_FLAG_TRAVERSE indicates that the iterator function for the
  271.  * indirect, doubly indirect, etc. blocks should be called after all
  272.  * of the blocks containined in the indirect blocks are processed.
  273.  * This is useful if you are going to be deallocating blocks from an
  274.  * inode.
  275.  *
  276.  * BLOCK_FLAG_DATA_ONLY indicates that the iterator function should be
  277.  * called for data blocks only.
  278.  *
  279.  * BLOCK_FLAG_NO_LARGE is for internal use only.  It informs
  280.  * ext2fs_block_iterate2 that large files won't be accepted.
  281.  */
  282. #define BLOCK_FLAG_APPEND    1
  283. #define BLOCK_FLAG_HOLE        1
  284. #define BLOCK_FLAG_DEPTH_TRAVERSE    2
  285. #define BLOCK_FLAG_DATA_ONLY    4
  286.  
  287. #define BLOCK_FLAG_NO_LARGE    0x1000
  288.  
  289. /*
  290.  * Magic "block count" return values for the block iterator function.
  291.  */
  292. #define BLOCK_COUNT_IND        (-1)
  293. #define BLOCK_COUNT_DIND    (-2)
  294. #define BLOCK_COUNT_TIND    (-3)
  295. #define BLOCK_COUNT_TRANSLATOR    (-4)
  296.  
  297. #if 0
  298. /*
  299.  * Flags for ext2fs_move_blocks
  300.  */
  301. #define EXT2_BMOVE_GET_DBLIST    0x0001    
  302. #define EXT2_BMOVE_DEBUG    0x0002
  303. #endif
  304.  
  305. /*
  306.  * Flags for directory block reading and writing functions
  307.  */
  308. #define EXT2_DIRBLOCK_V2_STRUCT    0x0001
  309.  
  310. /*
  311.  * Return flags for the directory iterator functions
  312.  */
  313. #define DIRENT_CHANGED    1
  314. #define DIRENT_ABORT    2
  315. #define DIRENT_ERROR    3
  316.  
  317. /*
  318.  * Directory iterator flags
  319.  */
  320.  
  321. #define DIRENT_FLAG_INCLUDE_EMPTY    1
  322. #define DIRENT_FLAG_INCLUDE_REMOVED    2
  323.  
  324. #define DIRENT_DOT_FILE        1
  325. #define DIRENT_DOT_DOT_FILE    2
  326. #define DIRENT_OTHER_FILE    3
  327. #define DIRENT_DELETED_FILE    4
  328.  
  329. /*
  330.  * Inode scan definitions
  331.  */
  332. typedef struct ext2_struct_inode_scan *ext2_inode_scan;
  333.  
  334. /*
  335.  * ext2fs_scan flags
  336.  */
  337. #define EXT2_SF_CHK_BADBLOCKS    0x0001
  338. #define EXT2_SF_BAD_INODE_BLK    0x0002
  339. #define EXT2_SF_BAD_EXTRA_BYTES    0x0004
  340. #define EXT2_SF_SKIP_MISSING_ITABLE    0x0008
  341.  
  342. /*
  343.  * ext2fs_check_if_mounted flags
  344.  */
  345. #define EXT2_MF_MOUNTED        1
  346. #define EXT2_MF_ISROOT        2
  347. #define EXT2_MF_READONLY    4
  348. #define EXT2_MF_SWAP        8
  349. #define EXT2_MF_BUSY        16
  350.  
  351. /*
  352.  * Ext2/linux mode flags.  We define them here so that we don't need
  353.  * to depend on the OS's sys/stat.h, since we may be compiling on a
  354.  * non-Linux system.
  355.  */
  356. #define LINUX_S_IFMT  00170000
  357. #define LINUX_S_IFSOCK 0140000
  358. #define LINUX_S_IFLNK     0120000
  359. #define LINUX_S_IFREG  0100000
  360. #define LINUX_S_IFBLK  0060000
  361. #define LINUX_S_IFDIR  0040000
  362. #define LINUX_S_IFCHR  0020000
  363. #define LINUX_S_IFIFO  0010000
  364. #define LINUX_S_ISUID  0004000
  365. #define LINUX_S_ISGID  0002000
  366. #define LINUX_S_ISVTX  0001000
  367.  
  368. #define LINUX_S_IRWXU 00700
  369. #define LINUX_S_IRUSR 00400
  370. #define LINUX_S_IWUSR 00200
  371. #define LINUX_S_IXUSR 00100
  372.  
  373. #define LINUX_S_IRWXG 00070
  374. #define LINUX_S_IRGRP 00040
  375. #define LINUX_S_IWGRP 00020
  376. #define LINUX_S_IXGRP 00010
  377.  
  378. #define LINUX_S_IRWXO 00007
  379. #define LINUX_S_IROTH 00004
  380. #define LINUX_S_IWOTH 00002
  381. #define LINUX_S_IXOTH 00001
  382.  
  383. #define LINUX_S_ISLNK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)
  384. #define LINUX_S_ISREG(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)
  385. #define LINUX_S_ISDIR(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)
  386. #define LINUX_S_ISCHR(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)
  387. #define LINUX_S_ISBLK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)
  388. #define LINUX_S_ISFIFO(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)
  389. #define LINUX_S_ISSOCK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)
  390.  
  391. /*
  392.  * ext2 size of an inode
  393.  */
  394. #define EXT2_I_SIZE(i)    ((i)->i_size | ((__u64) (i)->i_size_high << 32))
  395.  
  396. /*
  397.  * ext2_icount_t abstraction
  398.  */
  399. #define EXT2_ICOUNT_OPT_INCREMENT    0x01
  400.  
  401. typedef struct ext2_icount *ext2_icount_t;
  402.  
  403. /*
  404.  * Flags for ext2fs_bmap
  405.  */
  406. #define BMAP_ALLOC    0x0001
  407. #define BMAP_SET    0x0002
  408.  
  409. /*
  410.  * Flags for imager.c functions
  411.  */
  412. #define IMAGER_FLAG_INODEMAP    1
  413. #define IMAGER_FLAG_SPARSEWRITE    2
  414.  
  415. /*
  416.  * For checking structure magic numbers...
  417.  */
  418.  
  419. #define EXT2_CHECK_MAGIC(struct, code) \
  420.       if ((struct)->magic != (code)) return (code)
  421.  
  422.  
  423. /*
  424.  * For ext2 compression support
  425.  */
  426. #define EXT2FS_COMPRESSED_BLKADDR ((blk_t) 0xffffffff)
  427. #define HOLE_BLKADDR(_b) ((_b) == 0 || (_b) == EXT2FS_COMPRESSED_BLKADDR)
  428.  
  429. /*
  430.  * Features supported by this version of the library
  431.  */
  432. #define EXT2_LIB_FEATURE_COMPAT_SUPP    (EXT2_FEATURE_COMPAT_DIR_PREALLOC|\
  433.                      EXT2_FEATURE_COMPAT_IMAGIC_INODES|\
  434.                      EXT3_FEATURE_COMPAT_HAS_JOURNAL|\
  435.                      EXT2_FEATURE_COMPAT_RESIZE_INODE|\
  436.                      EXT2_FEATURE_COMPAT_DIR_INDEX|\
  437.                      EXT2_FEATURE_COMPAT_EXT_ATTR)
  438.  
  439. /* This #ifdef is temporary until compression is fully supported */
  440. #ifdef ENABLE_COMPRESSION
  441. #ifndef I_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL
  442. /* If the below warning bugs you, then have
  443.    `CPPFLAGS=-DI_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL' in your
  444.    environment at configure time. */
  445.  #warning "Compression support is experimental"
  446. #endif
  447. #define EXT2_LIB_FEATURE_INCOMPAT_SUPP    (EXT2_FEATURE_INCOMPAT_FILETYPE|\
  448.                      EXT2_FEATURE_INCOMPAT_COMPRESSION|\
  449.                      EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
  450.                      EXT2_FEATURE_INCOMPAT_META_BG|\
  451.                      EXT3_FEATURE_INCOMPAT_RECOVER)
  452. #else
  453. #define EXT2_LIB_FEATURE_INCOMPAT_SUPP    (EXT2_FEATURE_INCOMPAT_FILETYPE|\
  454.                      EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
  455.                      EXT2_FEATURE_INCOMPAT_META_BG|\
  456.                      EXT3_FEATURE_INCOMPAT_RECOVER)
  457. #endif
  458. #define EXT2_LIB_FEATURE_RO_COMPAT_SUPP    (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|\
  459.                      EXT2_FEATURE_RO_COMPAT_LARGE_FILE)
  460. /*
  461.  * function prototypes
  462.  */
  463.  
  464. /* alloc.c */
  465. extern errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, int mode,
  466.                   ext2fs_inode_bitmap map, ext2_ino_t *ret);
  467. extern errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal,
  468.                   ext2fs_block_bitmap map, blk_t *ret);
  469. extern errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start,
  470.                     blk_t finish, int num,
  471.                     ext2fs_block_bitmap map,
  472.                     blk_t *ret);
  473. extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
  474.                     char *block_buf, blk_t *ret);
  475.  
  476. /* alloc_sb.c */
  477. extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs, 
  478.                     dgrp_t group,
  479.                     ext2fs_block_bitmap bmap);
  480.  
  481. /* alloc_stats.c */
  482. void ext2fs_inode_alloc_stats(ext2_filsys fs, ext2_ino_t ino, int inuse);
  483. void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino,
  484.                    int inuse, int isdir);
  485. void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse);
  486.  
  487. /* alloc_tables.c */
  488. extern errcode_t ext2fs_allocate_tables(ext2_filsys fs);
  489. extern errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
  490.                          ext2fs_block_bitmap bmap);
  491.  
  492. /* badblocks.c */
  493. extern errcode_t ext2fs_u32_list_create(ext2_u32_list *ret, int size);
  494. extern errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk);
  495. extern int ext2fs_u32_list_find(ext2_u32_list bb, __u32 blk);
  496. extern int ext2fs_u32_list_test(ext2_u32_list bb, blk_t blk);
  497. extern errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb,
  498.                            ext2_u32_iterate *ret);
  499. extern int ext2fs_u32_list_iterate(ext2_u32_iterate iter, blk_t *blk);
  500. extern void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter);
  501. extern errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest);
  502. extern int ext2fs_u32_list_equal(ext2_u32_list bb1, ext2_u32_list bb2);
  503.  
  504. extern errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret,
  505.                         int size);
  506. extern errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb,
  507.                        blk_t blk);
  508. extern int ext2fs_badblocks_list_test(ext2_badblocks_list bb,
  509.                     blk_t blk);
  510. extern int ext2fs_u32_list_del(ext2_u32_list bb, __u32 blk);
  511. extern void ext2fs_badblocks_list_del(ext2_u32_list bb, __u32 blk);
  512. extern errcode_t
  513.     ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb,
  514.                         ext2_badblocks_iterate *ret);
  515. extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter,
  516.                      blk_t *blk);
  517. extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter);
  518. extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src,
  519.                        ext2_badblocks_list *dest);
  520. extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1,
  521.                   ext2_badblocks_list bb2);
  522. extern int ext2fs_u32_list_count(ext2_u32_list bb);
  523.  
  524. /* bb_compat */
  525. extern errcode_t badblocks_list_create(badblocks_list *ret, int size);
  526. extern errcode_t badblocks_list_add(badblocks_list bb, blk_t blk);
  527. extern int badblocks_list_test(badblocks_list bb, blk_t blk);
  528. extern errcode_t badblocks_list_iterate_begin(badblocks_list bb,
  529.                           badblocks_iterate *ret);
  530. extern int badblocks_list_iterate(badblocks_iterate iter, blk_t *blk);
  531. extern void badblocks_list_iterate_end(badblocks_iterate iter);
  532. extern void badblocks_list_free(badblocks_list bb);
  533.  
  534. /* bb_inode.c */
  535. extern errcode_t ext2fs_update_bb_inode(ext2_filsys fs,
  536.                     ext2_badblocks_list bb_list);
  537.  
  538. /* bitmaps.c */
  539. extern errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs);
  540. extern errcode_t ext2fs_write_block_bitmap (ext2_filsys fs);
  541. extern errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs);
  542. extern errcode_t ext2fs_read_block_bitmap(ext2_filsys fs);
  543. extern errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
  544.                         __u32 end,
  545.                         __u32 real_end,
  546.                         const char *descr,
  547.                         ext2fs_generic_bitmap *ret);
  548. extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
  549.                           const char *descr,
  550.                           ext2fs_block_bitmap *ret);
  551. extern errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
  552.                           const char *descr,
  553.                           ext2fs_inode_bitmap *ret);
  554. extern errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
  555.                            ext2_ino_t end, ext2_ino_t *oend);
  556. extern errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
  557.                            blk_t end, blk_t *oend);
  558. extern void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap);
  559. extern void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap);
  560. extern errcode_t ext2fs_read_bitmaps(ext2_filsys fs);
  561. extern errcode_t ext2fs_write_bitmaps(ext2_filsys fs);
  562.  
  563. /* block.c */
  564. extern errcode_t ext2fs_block_iterate(ext2_filsys fs,
  565.                       ext2_ino_t    ino,
  566.                       int    flags,
  567.                       char *block_buf,
  568.                       int (*func)(ext2_filsys fs,
  569.                           blk_t    *blocknr,
  570.                           int    blockcnt,
  571.                           void    *priv_data),
  572.                       void *priv_data);
  573. errcode_t ext2fs_block_iterate2(ext2_filsys fs,
  574.                 ext2_ino_t    ino,
  575.                 int    flags,
  576.                 char *block_buf,
  577.                 int (*func)(ext2_filsys fs,
  578.                         blk_t    *blocknr,
  579.                         e2_blkcnt_t    blockcnt,
  580.                         blk_t    ref_blk,
  581.                         int        ref_offset,
  582.                         void    *priv_data),
  583.                 void *priv_data);
  584.  
  585. /* bmap.c */
  586. extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
  587.                  struct ext2_inode *inode, 
  588.                  char *block_buf, int bmap_flags,
  589.                  blk_t block, blk_t *phys_blk);
  590.  
  591.  
  592. #if 0
  593. /* bmove.c */
  594. extern errcode_t ext2fs_move_blocks(ext2_filsys fs,
  595.                     ext2fs_block_bitmap reserve,
  596.                     ext2fs_block_bitmap alloc_map,
  597.                     int flags);
  598. #endif
  599.  
  600. /* check_desc.c */
  601. extern errcode_t ext2fs_check_desc(ext2_filsys fs);
  602.  
  603. /* closefs.c */
  604. extern errcode_t ext2fs_close(ext2_filsys fs);
  605. extern errcode_t ext2fs_flush(ext2_filsys fs);
  606. extern int ext2fs_bg_has_super(ext2_filsys fs, int group_block);
  607. extern int ext2fs_super_and_bgd_loc(ext2_filsys fs, 
  608.                     dgrp_t group,
  609.                     blk_t *ret_super_blk,
  610.                     blk_t *ret_old_desc_blk,
  611.                     blk_t *ret_new_desc_blk,
  612.                     int *ret_meta_bg);
  613. extern void ext2fs_update_dynamic_rev(ext2_filsys fs);
  614.  
  615. /* cmp_bitmaps.c */
  616. extern errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
  617.                          ext2fs_block_bitmap bm2);
  618. extern errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
  619.                          ext2fs_inode_bitmap bm2);
  620.  
  621. /* dblist.c */
  622.  
  623. extern errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs);
  624. extern errcode_t ext2fs_init_dblist(ext2_filsys fs, ext2_dblist *ret_dblist);
  625. extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino,
  626.                       blk_t blk, int blockcnt);
  627. extern void ext2fs_dblist_sort(ext2_dblist dblist,
  628.                    EXT2_QSORT_TYPE (*sortfunc)(const void *,
  629.                                const void *));
  630. extern errcode_t ext2fs_dblist_iterate(ext2_dblist dblist,
  631.     int (*func)(ext2_filsys fs, struct ext2_db_entry *db_info,
  632.             void    *priv_data),
  633.        void *priv_data);
  634. extern errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino,
  635.                       blk_t blk, int blockcnt);
  636. extern errcode_t ext2fs_copy_dblist(ext2_dblist src,
  637.                     ext2_dblist *dest);
  638. extern int ext2fs_dblist_count(ext2_dblist dblist);
  639.  
  640. /* dblist_dir.c */
  641. extern errcode_t
  642.     ext2fs_dblist_dir_iterate(ext2_dblist dblist,
  643.                   int    flags,
  644.                   char    *block_buf,
  645.                   int (*func)(ext2_ino_t    dir,
  646.                           int        entry,
  647.                           struct ext2_dir_entry *dirent,
  648.                           int    offset,
  649.                           int    blocksize,
  650.                           char    *buf,
  651.                           void    *priv_data),
  652.                   void *priv_data);
  653.  
  654. /* dirblock.c */
  655. extern errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block,
  656.                        void *buf);
  657. extern errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
  658.                     void *buf, int flags);
  659. extern errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
  660.                     void *buf);
  661. extern errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
  662.                      void *buf, int flags);
  663.  
  664. /* dirhash.c */
  665. extern errcode_t ext2fs_dirhash(int version, const char *name, int len,
  666.                 const __u32 *seed,
  667.                 ext2_dirhash_t *ret_hash,
  668.                 ext2_dirhash_t *ret_minor_hash);
  669.  
  670.  
  671. /* dir_iterate.c */
  672. extern errcode_t ext2fs_dir_iterate(ext2_filsys fs, 
  673.                   ext2_ino_t dir,
  674.                   int flags,
  675.                   char *block_buf,
  676.                   int (*func)(struct ext2_dir_entry *dirent,
  677.                       int    offset,
  678.                       int    blocksize,
  679.                       char    *buf,
  680.                       void    *priv_data),
  681.                   void *priv_data);
  682. extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs, 
  683.                   ext2_ino_t dir,
  684.                   int flags,
  685.                   char *block_buf,
  686.                   int (*func)(ext2_ino_t    dir,
  687.                       int    entry,
  688.                       struct ext2_dir_entry *dirent,
  689.                       int    offset,
  690.                       int    blocksize,
  691.                       char    *buf,
  692.                       void    *priv_data),
  693.                   void *priv_data);
  694.  
  695. /* dupfs.c */
  696. extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest);
  697.  
  698. /* expanddir.c */
  699. extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir);
  700.  
  701. /* ext_attr.c */
  702. extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf);
  703. extern errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block,
  704.                        void *buf);
  705. extern errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
  706.                        char *block_buf,
  707.                        int adjust, __u32 *newcount);
  708.  
  709. /* fileio.c */
  710. extern errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
  711.                    struct ext2_inode *inode,
  712.                    int flags, ext2_file_t *ret);
  713. extern errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino,
  714.                   int flags, ext2_file_t *ret);
  715. extern ext2_filsys ext2fs_file_get_fs(ext2_file_t file);
  716. extern errcode_t ext2fs_file_close(ext2_file_t file);
  717. extern errcode_t ext2fs_file_flush(ext2_file_t file);
  718. extern errcode_t ext2fs_file_read(ext2_file_t file, void *buf,
  719.                   unsigned int wanted, unsigned int *got);
  720. extern errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
  721.                    unsigned int nbytes, unsigned int *written);
  722. extern errcode_t ext2fs_file_llseek(ext2_file_t file, __u64 offset,
  723.                    int whence, __u64 *ret_pos);
  724. extern errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
  725.                    int whence, ext2_off_t *ret_pos);
  726. errcode_t ext2fs_file_get_lsize(ext2_file_t file, __u64 *ret_size);
  727. extern ext2_off_t ext2fs_file_get_size(ext2_file_t file);
  728. extern errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size);
  729.  
  730. /* finddev.c */
  731. extern char *ext2fs_find_block_device(dev_t device);
  732.  
  733. /* flushb.c */
  734. extern errcode_t ext2fs_sync_device(int fd, int flushb);
  735.  
  736. /* freefs.c */
  737. extern void ext2fs_free(ext2_filsys fs);
  738. extern void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap);
  739. extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap);
  740. extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap);
  741. extern void ext2fs_free_dblist(ext2_dblist dblist);
  742. extern void ext2fs_badblocks_list_free(ext2_badblocks_list bb);
  743. extern void ext2fs_u32_list_free(ext2_u32_list bb);
  744.  
  745. /* getsize.c */
  746. extern errcode_t ext2fs_get_device_size(const char *file, int blocksize,
  747.                     blk_t *retblocks);
  748.  
  749. /* getsectsize.c */
  750. errcode_t ext2fs_get_device_sectsize(const char *file, int *sectsize);
  751.  
  752. /* imager.c */
  753. extern errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags);
  754. extern errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, int flags);
  755. extern errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, int flags);
  756. extern errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, int flags);
  757. extern errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags);
  758. extern errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags);
  759.  
  760. /* ind_block.c */
  761. errcode_t ext2fs_read_ind_block(ext2_filsys fs, blk_t blk, void *buf);
  762. errcode_t ext2fs_write_ind_block(ext2_filsys fs, blk_t blk, void *buf);
  763.  
  764. /* initialize.c */
  765. extern errcode_t ext2fs_initialize(const char *name, int flags,
  766.                    struct ext2_super_block *param,
  767.                    io_manager manager, ext2_filsys *ret_fs);
  768.  
  769. /* icount.c */
  770. extern void ext2fs_free_icount(ext2_icount_t icount);
  771. extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags, 
  772.                        unsigned int size,
  773.                        ext2_icount_t hint, ext2_icount_t *ret);
  774. extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags, 
  775.                       unsigned int size,
  776.                       ext2_icount_t *ret);
  777. extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino,
  778.                      __u16 *ret);
  779. extern errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino,
  780.                      __u16 *ret);
  781. extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
  782.                      __u16 *ret);
  783. extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
  784.                      __u16 count);
  785. extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount);
  786. errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
  787.  
  788. /* inode.c */
  789. extern errcode_t ext2fs_flush_icache(ext2_filsys fs);
  790. extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, 
  791.                         ext2_ino_t *ino,
  792.                         struct ext2_inode *inode, 
  793.                         int bufsize);
  794. extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
  795.                   ext2_inode_scan *ret_scan);
  796. extern void ext2fs_close_inode_scan(ext2_inode_scan scan);
  797. extern errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
  798.                    struct ext2_inode *inode);
  799. extern errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan,
  800.                            int    group);
  801. extern void ext2fs_set_inode_callback
  802.     (ext2_inode_scan scan,
  803.      errcode_t (*done_group)(ext2_filsys fs,
  804.                  ext2_inode_scan scan,
  805.                  dgrp_t group,
  806.                  void * priv_data),
  807.      void *done_group_data);
  808. extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags,
  809.                    int clear_flags);
  810. extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
  811.                     struct ext2_inode * inode, 
  812.                     int bufsize);
  813. extern errcode_t ext2fs_read_inode (ext2_filsys fs, ext2_ino_t ino,
  814.                 struct ext2_inode * inode);
  815. extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
  816.                      struct ext2_inode * inode, 
  817.                      int bufsize);
  818. extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
  819.                 struct ext2_inode * inode);
  820. extern errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
  821.                 struct ext2_inode * inode);
  822. extern errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
  823. extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino);
  824.  
  825. /* inode_io.c */
  826. extern io_manager inode_io_manager;
  827. extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino, 
  828.                     char **name);
  829. extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
  830.                      struct ext2_inode *inode,
  831.                      char **name);
  832.     
  833. /* ismounted.c */
  834. extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags);
  835. extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
  836.                       char *mtpt, int mtlen);
  837.  
  838. /* namei.c */
  839. extern errcode_t ext2fs_lookup(ext2_filsys fs, ext2_ino_t dir, const char *name,
  840.              int namelen, char *buf, ext2_ino_t *inode);
  841. extern errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  842.             const char *name, ext2_ino_t *inode);
  843. errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  844.                   const char *name, ext2_ino_t *inode);
  845. extern errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  846.             ext2_ino_t inode, ext2_ino_t *res_inode);
  847.  
  848. /* native.c */
  849. int ext2fs_native_flag(void);
  850.  
  851. /* newdir.c */
  852. extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
  853.                 ext2_ino_t parent_ino, char **block);
  854.  
  855. /* mkdir.c */
  856. extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
  857.                   const char *name);
  858.  
  859. /* mkjournal.c */
  860. extern errcode_t ext2fs_create_journal_superblock(ext2_filsys fs,
  861.                           __u32 size, int flags,
  862.                           char  **ret_jsb);
  863. extern errcode_t ext2fs_add_journal_device(ext2_filsys fs,
  864.                        ext2_filsys journal_dev);
  865. extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size,
  866.                       int flags);
  867.  
  868. /* openfs.c */
  869. extern errcode_t ext2fs_open(const char *name, int flags, int superblock,
  870.                  unsigned int block_size, io_manager manager,
  871.                  ext2_filsys *ret_fs);
  872. extern errcode_t ext2fs_open2(const char *name, const char *io_options, 
  873.                   int flags, int superblock, 
  874.                   unsigned int block_size, io_manager manager,
  875.                   ext2_filsys *ret_fs);
  876. extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, 
  877.                      dgrp_t i);
  878. errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io);
  879. errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io);
  880. errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io);
  881.  
  882. /* get_pathname.c */
  883. extern errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino,
  884.                    char **name);
  885.  
  886. /* link.c */
  887. errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name,
  888.               ext2_ino_t ino, int flags);
  889. errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir, const char *name,
  890.             ext2_ino_t ino, int flags);
  891.  
  892. /* read_bb.c */
  893. extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs,
  894.                       ext2_badblocks_list *bb_list);
  895.  
  896. /* read_bb_file.c */
  897. extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f, 
  898.                       ext2_badblocks_list *bb_list,
  899.                       void *priv_data,
  900.                       void (*invalid)(ext2_filsys fs,
  901.                               blk_t blk,
  902.                               char *badstr,
  903.                               void *priv_data));
  904. extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f, 
  905.                      ext2_badblocks_list *bb_list,
  906.                      void (*invalid)(ext2_filsys fs,
  907.                              blk_t blk));
  908.  
  909. /* res_gdt.c */
  910. extern errcode_t ext2fs_create_resize_inode(ext2_filsys fs);
  911.  
  912. /* rs_bitmap.c */
  913. extern errcode_t ext2fs_resize_generic_bitmap(__u32 new_end,
  914.                           __u32 new_real_end,
  915.                           ext2fs_generic_bitmap bmap);
  916. extern errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
  917.                         ext2fs_inode_bitmap bmap);
  918. extern errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
  919.                         ext2fs_block_bitmap bmap);
  920. extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
  921.                     ext2fs_generic_bitmap *dest);
  922.  
  923. /* swapfs.c */
  924. extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize, 
  925.                  int has_header);
  926. extern void ext2fs_swap_super(struct ext2_super_block * super);
  927. extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
  928. extern void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t,
  929.                    struct ext2_inode_large *f, int hostorder,
  930.                    int bufsize);
  931. extern void ext2fs_swap_inode(ext2_filsys fs,struct ext2_inode *t,
  932.                   struct ext2_inode *f, int hostorder);
  933.  
  934. /* valid_blk.c */
  935. extern int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode);
  936.  
  937. /* version.c */
  938. extern int ext2fs_parse_version_string(const char *ver_string);
  939. extern int ext2fs_get_library_version(const char **ver_string,
  940.                       const char **date_string);
  941.  
  942. /* write_bb_file.c */
  943. extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list,
  944.                       unsigned int flags,
  945.                       FILE *f);
  946.  
  947.  
  948. /* inline functions */
  949. extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
  950. extern errcode_t ext2fs_free_mem(void *ptr);
  951. extern errcode_t ext2fs_resize_mem(unsigned long old_size,
  952.                    unsigned long size, void *ptr);
  953. extern void ext2fs_mark_super_dirty(ext2_filsys fs);
  954. extern void ext2fs_mark_changed(ext2_filsys fs);
  955. extern int ext2fs_test_changed(ext2_filsys fs);
  956. extern void ext2fs_mark_valid(ext2_filsys fs);
  957. extern void ext2fs_unmark_valid(ext2_filsys fs);
  958. extern int ext2fs_test_valid(ext2_filsys fs);
  959. extern void ext2fs_mark_ib_dirty(ext2_filsys fs);
  960. extern void ext2fs_mark_bb_dirty(ext2_filsys fs);
  961. extern int ext2fs_test_ib_dirty(ext2_filsys fs);
  962. extern int ext2fs_test_bb_dirty(ext2_filsys fs);
  963. extern int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk);
  964. extern int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino);
  965. extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
  966.                       struct ext2_inode *inode);
  967.  
  968. /*
  969.  * The actual inlined functions definitions themselves...
  970.  *
  971.  * If NO_INLINE_FUNCS is defined, then we won't try to do inline
  972.  * functions at all!
  973.  */
  974. #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
  975. #ifdef INCLUDE_INLINE_FUNCS
  976. #define _INLINE_ extern
  977. #else
  978. #ifdef __GNUC__
  979. #define _INLINE_ extern __inline__
  980. #else                /* For Watcom C */
  981. #define _INLINE_ extern inline
  982. #endif
  983. #endif
  984.  
  985. #ifndef EXT2_CUSTOM_MEMORY_ROUTINES
  986. /*
  987.  *  Allocate memory
  988.  */
  989. _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
  990. {
  991.     void **pp = (void **)ptr;
  992.  
  993.     *pp = malloc(size);
  994.     if (!*pp)
  995.         return EXT2_ET_NO_MEMORY;
  996.     return 0;
  997. }
  998.  
  999. /*
  1000.  * Free memory
  1001.  */
  1002. _INLINE_ errcode_t ext2fs_free_mem(void *ptr)
  1003. {
  1004.     void **pp = (void **)ptr;
  1005.  
  1006.     free(*pp);
  1007.     *pp = 0;
  1008.     return 0;
  1009. }
  1010.     
  1011. /*
  1012.  *  Resize memory
  1013.  */
  1014. _INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
  1015.                      unsigned long size, void *ptr)
  1016. {
  1017.     void *p;
  1018.  
  1019.     /* Use "memcpy" for pointer assignments here to avoid problems
  1020.      * with C99 strict type aliasing rules. */
  1021.     memcpy(&p, ptr, sizeof (p));
  1022.     p = realloc(p, size);
  1023.     if (!p)
  1024.         return EXT2_ET_NO_MEMORY;
  1025.     memcpy(ptr, &p, sizeof (p));
  1026.     return 0;
  1027. }
  1028. #endif    /* Custom memory routines */
  1029.  
  1030. /*
  1031.  * Mark a filesystem superblock as dirty
  1032.  */
  1033. _INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs)
  1034. {
  1035.     fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED;
  1036. }
  1037.  
  1038. /*
  1039.  * Mark a filesystem as changed
  1040.  */
  1041. _INLINE_ void ext2fs_mark_changed(ext2_filsys fs)
  1042. {
  1043.     fs->flags |= EXT2_FLAG_CHANGED;
  1044. }
  1045.  
  1046. /*
  1047.  * Check to see if a filesystem has changed
  1048.  */
  1049. _INLINE_ int ext2fs_test_changed(ext2_filsys fs)
  1050. {
  1051.     return (fs->flags & EXT2_FLAG_CHANGED);
  1052. }
  1053.  
  1054. /*
  1055.  * Mark a filesystem as valid
  1056.  */
  1057. _INLINE_ void ext2fs_mark_valid(ext2_filsys fs)
  1058. {
  1059.     fs->flags |= EXT2_FLAG_VALID;
  1060. }
  1061.  
  1062. /*
  1063.  * Mark a filesystem as NOT valid
  1064.  */
  1065. _INLINE_ void ext2fs_unmark_valid(ext2_filsys fs)
  1066. {
  1067.     fs->flags &= ~EXT2_FLAG_VALID;
  1068. }
  1069.  
  1070. /*
  1071.  * Check to see if a filesystem is valid
  1072.  */
  1073. _INLINE_ int ext2fs_test_valid(ext2_filsys fs)
  1074. {
  1075.     return (fs->flags & EXT2_FLAG_VALID);
  1076. }
  1077.  
  1078. /*
  1079.  * Mark the inode bitmap as dirty
  1080.  */
  1081. _INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs)
  1082. {
  1083.     fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED;
  1084. }
  1085.  
  1086. /*
  1087.  * Mark the block bitmap as dirty
  1088.  */
  1089. _INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs)
  1090. {
  1091.     fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED;
  1092. }
  1093.  
  1094. /*
  1095.  * Check to see if a filesystem's inode bitmap is dirty
  1096.  */
  1097. _INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs)
  1098. {
  1099.     return (fs->flags & EXT2_FLAG_IB_DIRTY);
  1100. }
  1101.  
  1102. /*
  1103.  * Check to see if a filesystem's block bitmap is dirty
  1104.  */
  1105. _INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs)
  1106. {
  1107.     return (fs->flags & EXT2_FLAG_BB_DIRTY);
  1108. }
  1109.  
  1110. /*
  1111.  * Return the group # of a block
  1112.  */
  1113. _INLINE_ int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
  1114. {
  1115.     return (blk - fs->super->s_first_data_block) /
  1116.         fs->super->s_blocks_per_group;
  1117. }
  1118.  
  1119. /*
  1120.  * Return the group # of an inode number
  1121.  */
  1122. _INLINE_ int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
  1123. {
  1124.     return (ino - 1) / fs->super->s_inodes_per_group;
  1125. }
  1126.  
  1127. _INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
  1128.                     struct ext2_inode *inode)
  1129. {
  1130.        return inode->i_blocks -
  1131.               (inode->i_file_acl ? fs->blocksize >> 9 : 0);
  1132. }
  1133. #undef _INLINE_
  1134. #endif
  1135.  
  1136. #ifdef __cplusplus
  1137. }
  1138. #endif
  1139.  
  1140. #endif /* _EXT2FS_EXT2FS_H */
  1141.